export default class websocket {
  constructor({ heartCheck, isReconnection }) {
    // 是否连接
    this._isLogin = false;
    // 当前网络状态
    this._netWork = true;
    // 是否人为退出
    this._isClosed = false;
    // 心跳检测频率
    this._timeout = 3000;
    this._timeoutObj = null;
    this.timeOut = null;
    // 当前重连次数
    this._connectNum = 0;
    // 心跳检测和断线重连开关，true为启用，false为关闭
    this._heartCheck = heartCheck;
    this._isReconnection = true;
    this._onSocketOpened();
  }
  // 心跳重置
  _reset() {
    clearInterval(this._timeoutObj);
    return this;
  }
  // 心跳开始
  _start() {
    let _this = this;
    this._timeoutObj = setInterval(() => {
      clearTimeout(_this.timeOut)
      _this.timeOut = setTimeout(function() {
        _this._onSocketOpened()
      },6000)
      wx.sendSocketMessage({
        // 心跳发送的信息应由前后端商量后决定
        data: 'ping',
        success(res) {
          console.log("socket--发送心跳成功");
        },
        fail(err) {
          console.error("socket--发送消息失败", err)
          _this._reset()
        }
      });
    }, this._timeout);
  }
  // 监听websocket连接关闭
  onSocketClosed(options) {
    wx.onSocketClose(err => {
      console.log('socket--监听关闭连接' + JSON.stringify(err));
      // 停止心跳连接
      if (this._heartCheck) {
        this._reset();
      }
      // 关闭已登录开关
      this._isLogin = false;
      console.log("socket--登录状态", this._isLogin);

      // 检测是否是用户自己退出小程序
      if (!this._isClosed) {
        // 进行重连
        if (this._isReconnection) {
          this._reConnect(options)
        }
      }
    })
  }
  // 检测网络变化
  onNetworkChange(options) {
    wx.onNetworkStatusChange(res => {
      console.log('socket--当前网络状态:' + res.isConnected);
      if (!this._netWork) {
        this._isLogin = false;
        // 进行重连
        if (this._isReconnection) {
          this._reConnect(options)
        }
      }
    })
  }

  _onSocketOpened() {
    wx.onSocketOpen(res => {
      console.log('socket--连接已打开');
      // 打开已登录开关
      this._isLogin = true;
      // 发送心跳
      if (this._heartCheck) {
        this._reset()._start();
      }
      // 发送登录信息
      wx.sendSocketMessage({
        // 这里是第一次建立连接所发送的信息，应由前后端商量后决定
        data: 'ping'
      })
      // 打开网络开关
      this._netWork = true;
      clearTimeout(this.timeOut)
    })
  }

  /**
   *  监听socket异常
   * @param {*} options 
   */
  onSocketError(options) {
    wx.onSocketError(res => {
      console.error('socket--连接打开失败', res)
      let _this = this;
      wx.closeSocket({
        success(res) {
          console.log('socket--关闭socket成功', res);
        },
        fail(res) {  //  接口调用失败的回调函数
          console.error('socket--关闭socket失败', res);
          //  重新连接
          _this._reConnect(options);
        }
      });
    })
  }

  // 接收服务器返回的消息
  onReceivedMsg(callBack) {
    wx.onSocketMessage(msg => {
      if (typeof callBack == "function") {
        callBack(msg)
        if ((msg.data).indexOf('pong') == -1) {
          wx.sendSocketMessage({
            // 心跳发送的信息应由前后端商量后决定
            data: msg.data,
            success(res) {
              console.log("发送信息成功");
            },
            fail(err) {
              console.error("socket--发送消息失败", err)
              _this._reset()
            }
          });
        }
      } else {
        console.error('socket--参数的类型必须为函数')
      }
    })
  }

  // 建立websocket连接
  initWebSocket(options) {
    let _this = this;
    if (this._isLogin) {
      console.log("socket--您已经登录了");
    } else {
      // 检查网络
      wx.getNetworkType({
        success(result) {
          if (result.networkType != 'none') {
            // 开始建立连接
            console.log("socket--开始创建socket连接");
            wx.connectSocket({
              url: options.url,
              timeout: 999999999,
              success(res) {
                console.log("socket--创建socket连接成功--后台socket服务不一定开启", res, options);
                if (typeof options.success == "function") {
                  options.success(res)
                } else {
                  console.error('socket--参数的类型必须为函数')
                }
              },
              fail(err) {
                console.error("socket--创建socket连接失败", res);
                if (typeof options.fail == "function") {
                  options.fail(err)
                } else {
                  console.error('socket--参数的类型必须为函数')
                }
              },
              complete(res) {
                console.log("socket--连接socket--complete", res);
              }
            })
          } else {
            console.log('socket--网络已断开');
            _this._netWork = false;
            // 网络断开后显示model
            wx.showModal({
              title: '网络错误',
              content: '请重新打开网络',
              showCancel: false,
              success: function (res) {
                if (res.confirm) {
                  console.log('socket--用户点击确定')
                }
              }
            })
          }
        }
      })
    }
  }

  // 发送websocket消息
  sendWebSocketMsg(options) {
    wx.sendSocketMessage({
      data: options.data,
      success(res) {
        if (typeof options.success == "function") {
          options.success(res)
        } else {
          console.log('socket--参数的类型必须为函数')
        }
      },
      fail(err) {
        if (typeof options.fail == "function") {
          options.fail(err)
        } else {
          console.error('socket--参数的类型必须为函数')
        }
      }
    })
  }
  // 重连方法，会根据时间频率越来越慢
  _reConnect(options) {
    // this.initWebSocket(options);
    let timer, _this = this;
    // if (this._connectNum < 20) {
    timer = setTimeout(() => {
      console.log("socket--重新连接");
      this.initWebSocket(options)
    }, 3000)
    //   this._connectNum += 1;
    // } else if (this._connectNum < 50) {
    //   timer = setTimeout(() => {
    //     this.initWebSocket(options)
    //   }, 10000)
    //   this._connectNum += 1;
    // } else {
    //   timer = setTimeout(() => {
    //     this.initWebSocket(options)
    //   }, 450000)
    //   this._connectNum += 1;
    // }
  }
  // 关闭websocket连接
  closeWebSocket() {
    wx.closeSocket({
      success(res) {
        console.log("socket--关闭连接", res);
      },
      fail(error){
        console.error("socket--关闭连接失败", error)
      }
    });
    this._isClosed = true;
  }
}